<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">

<title>class Matrix::LUPDecomposition - matrix: Ruby Standard Library Documentation</title>


<script src="../js/navigation.js" defer></script>
<script src="../js/search.js" defer></script>
<script src="../js/search_index.js" defer></script>
<script src="../js/searcher.js" defer></script>
<script src="../js/darkfish.js" defer></script>

<script src="../js/jquery-3.2.0.min.js"></script>

<script src="../js/vue.min.js"></script>
<script src="../js/js.cookie.min.js"></script>

<link href="../css/fonts.css" rel="stylesheet">
<link id='rdoccss' href="../css/rdoc.css" rel="stylesheet">
<link href="../css/carbon17.css" rel="stylesheet">

<script type="text/javascript">
  var rdoc_rel_prefix = "../";
  var index_rel_prefix = "../";
  var darkModeCsseHref = "../css/rdoc-dm.css"
  var defaultModeCssHref = "../css/rdoc.css"
  // var cssDarkmode = Cookies.get('darkmode');
  
  if( Cookies.get("darkmode") == "true") {
	$('#rdoccss').attr("href", darkModeCsseHref);
}

//  https://cssdeck.com/blog/simple-jquery-stylesheet-switcher/

document.write('<style type="text/css">body{display:none}</style>');

</script>


</head>
<body id="top" role="document" class="class">
  <!-- this is class.html -->

  <div id='actionbar' >
    <div class='wrapper mdiv'>
      <ul class='grids g0'></ul>
    </div> 
    <!-- VERSION HEADER for 3.3.0.preview2 NOT FOUND -->
  </div> <!-- end action bar -->

  <div class='wrapper hdiv'>

    


    <nav id='vapp' role="navigation">
    <div id="project-navigation">
      <div id="home-section" role="region" title="Quick navigation" class="nav-section">
  <h2><a href="../index.html" rel="home">Home</a></h2>

  <div id="table-of-contents-navigation"  >
    <a href="../table_of_contents.html#pages">Pages</a>
    <a href="../table_of_contents.html#classes">Classes</a>
    <a href="../table_of_contents.html#methods">Methods</a>
  </div>
</div>

      <div id="search-section" role="search" class="project-section initially-hidden">
  <form action="#" method="get" accept-charset="utf-8">
    <div id="search-field-wrapper">
      <input id="search-field" role="combobox" aria-label="Search"
             aria-autocomplete="list" aria-controls="search-results"
             type="text" name="search" placeholder="Search" spellcheck="false"
             title="Type to search, Up and Down to navigate, Enter to load">
    </div>

    <ul id="search-results" aria-label="Search Results"
        aria-busy="false" aria-expanded="false"
        aria-atomic="false" class="initially-hidden"></ul>
  </form>
</div>

    </div>


    

    <button id='toggleThing' @click="toggleNav()" >Show/hide navigation</button>
    <div :class="isOpen ? 'block' : 'hidden' " id='toggleMe'>
      <div id="class-metadata">
        
        
<div id="parent-class-section" class="nav-section">
  <h3>Parent</h3>

  <p class="link">Object
</div>

        
        
        
<!-- Method Quickref -->
<div id="method-list-section" class="nav-section">
  <h3>Methods</h3>

  <ul class="link-list" role="directory">
    <li ><a href="#method-c-new">::new</a>
    <li ><a href="#method-i-det">#det</a>
    <li ><a href="#method-i-determinant">#determinant</a>
    <li ><a href="#method-i-l">#l</a>
    <li ><a href="#method-i-p">#p</a>
    <li ><a href="#method-i-singular-3F">#singular?</a>
    <li ><a href="#method-i-solve">#solve</a>
    <li ><a href="#method-i-to_a">#to_a</a>
    <li ><a href="#method-i-to_ary">#to_ary</a>
    <li ><a href="#method-i-u">#u</a>
  </ul>
</div>

      </div>
     </div>
    </nav>


    <div id='extraz'><div class='adzbox-index'  >
      
     </div>         
    </div>

    <main role="main" aria-labelledby="class-Matrix::LUPDecomposition">
    <h1 id="class-Matrix::LUPDecomposition" class="class">
      class Matrix::LUPDecomposition
    </h1>

    <section class="description">
    
<p>For an m-by-n matrix A with m &gt;= n, the LU decomposition is an m-by-n unit lower triangular matrix L, an n-by-n upper triangular matrix U, and a m-by-m permutation matrix P so that L*U = P*A. If m &lt; n, then L is m-by-m and U is m-by-n.</p>

<p>The LUP decomposition with pivoting always exists, even if the matrix is singular, so the constructor will never fail.  The primary use of the LU decomposition is in the solution of square systems of simultaneous linear equations.  This will fail if singular? returns true.</p>

    </section>

      <section id="5Buntitled-5D" class="documentation-section">



        <section class="attribute-method-details" class="method-section">
        <header>
        <h3>Attributes</h3>
        </header>

          <div id="attribute-i-pivots" class="method-detail">
            <div class="method-heading attribute-method-heading">
              <span class="method-name">pivots</span><span
                class="attribute-access-type">[R]</span>
            </div>

            <div class="method-description">
              <p>Returns the pivoting indices</p>
              </div>
            </div>
            </section>


                <section id="public-class-5Buntitled-5D-method-details" class="method-section">
                <header>
                <h3>Public Class Methods</h3>
                </header>

                  <div id="method-c-new" class="method-detail ">
                            <div class="method-heading">
                              <span class="method-name">new</span><span
                                class="method-args">(a)</span>
                              <span class="method-click-advice">click to toggle source</span>
                            </div>

                            <div class="method-description">
                              

                              <div class="method-source-code" id="new-source">
            <pre><span class="ruby-comment"># File matrix-0.4.2/lib/matrix/lup_decomposition.rb, line 154</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">initialize</span> <span class="ruby-identifier">a</span>
  <span class="ruby-identifier">raise</span> <span class="ruby-constant">TypeError</span>, <span class="ruby-node">&quot;Expected Matrix but got #{a.class}&quot;</span> <span class="ruby-keyword">unless</span> <span class="ruby-identifier">a</span>.<span class="ruby-identifier">is_a?</span>(<span class="ruby-constant">Matrix</span>)
  <span class="ruby-comment"># Use a &quot;left-looking&quot;, dot-product, Crout/Doolittle algorithm.</span>
  <span class="ruby-ivar">@lu</span> = <span class="ruby-identifier">a</span>.<span class="ruby-identifier">to_a</span>
  <span class="ruby-ivar">@row_count</span> = <span class="ruby-identifier">a</span>.<span class="ruby-identifier">row_count</span>
  <span class="ruby-ivar">@column_count</span> = <span class="ruby-identifier">a</span>.<span class="ruby-identifier">column_count</span>
  <span class="ruby-ivar">@pivots</span> = <span class="ruby-constant">Array</span>.<span class="ruby-identifier">new</span>(<span class="ruby-ivar">@row_count</span>)
  <span class="ruby-ivar">@row_count</span>.<span class="ruby-identifier">times</span> <span class="ruby-keyword">do</span> <span class="ruby-operator">|</span><span class="ruby-identifier">i</span><span class="ruby-operator">|</span>
     <span class="ruby-ivar">@pivots</span>[<span class="ruby-identifier">i</span>] = <span class="ruby-identifier">i</span>
  <span class="ruby-keyword">end</span>
  <span class="ruby-ivar">@pivot_sign</span> = <span class="ruby-value">1</span>
  <span class="ruby-identifier">lu_col_j</span> = <span class="ruby-constant">Array</span>.<span class="ruby-identifier">new</span>(<span class="ruby-ivar">@row_count</span>)

  <span class="ruby-comment"># Outer loop.</span>

  <span class="ruby-ivar">@column_count</span>.<span class="ruby-identifier">times</span> <span class="ruby-keyword">do</span> <span class="ruby-operator">|</span><span class="ruby-identifier">j</span><span class="ruby-operator">|</span>

    <span class="ruby-comment"># Make a copy of the j-th column to localize references.</span>

    <span class="ruby-ivar">@row_count</span>.<span class="ruby-identifier">times</span> <span class="ruby-keyword">do</span> <span class="ruby-operator">|</span><span class="ruby-identifier">i</span><span class="ruby-operator">|</span>
      <span class="ruby-identifier">lu_col_j</span>[<span class="ruby-identifier">i</span>] = <span class="ruby-ivar">@lu</span>[<span class="ruby-identifier">i</span>][<span class="ruby-identifier">j</span>]
    <span class="ruby-keyword">end</span>

    <span class="ruby-comment"># Apply previous transformations.</span>

    <span class="ruby-ivar">@row_count</span>.<span class="ruby-identifier">times</span> <span class="ruby-keyword">do</span> <span class="ruby-operator">|</span><span class="ruby-identifier">i</span><span class="ruby-operator">|</span>
      <span class="ruby-identifier">lu_row_i</span> = <span class="ruby-ivar">@lu</span>[<span class="ruby-identifier">i</span>]

      <span class="ruby-comment"># Most of the time is spent in the following dot product.</span>

      <span class="ruby-identifier">kmax</span> = [<span class="ruby-identifier">i</span>, <span class="ruby-identifier">j</span>].<span class="ruby-identifier">min</span>
      <span class="ruby-identifier">s</span> = <span class="ruby-value">0</span>
      <span class="ruby-identifier">kmax</span>.<span class="ruby-identifier">times</span> <span class="ruby-keyword">do</span> <span class="ruby-operator">|</span><span class="ruby-identifier">k</span><span class="ruby-operator">|</span>
        <span class="ruby-identifier">s</span> <span class="ruby-operator">+=</span> <span class="ruby-identifier">lu_row_i</span>[<span class="ruby-identifier">k</span>]<span class="ruby-operator">*</span><span class="ruby-identifier">lu_col_j</span>[<span class="ruby-identifier">k</span>]
      <span class="ruby-keyword">end</span>

      <span class="ruby-identifier">lu_row_i</span>[<span class="ruby-identifier">j</span>] = <span class="ruby-identifier">lu_col_j</span>[<span class="ruby-identifier">i</span>] <span class="ruby-operator">-=</span> <span class="ruby-identifier">s</span>
    <span class="ruby-keyword">end</span>

    <span class="ruby-comment"># Find pivot and exchange if necessary.</span>

    <span class="ruby-identifier">p</span> = <span class="ruby-identifier">j</span>
    (<span class="ruby-identifier">j</span><span class="ruby-value">+1</span>).<span class="ruby-identifier">upto</span>(<span class="ruby-ivar">@row_count</span><span class="ruby-value">-1</span>) <span class="ruby-keyword">do</span> <span class="ruby-operator">|</span><span class="ruby-identifier">i</span><span class="ruby-operator">|</span>
      <span class="ruby-keyword">if</span> (<span class="ruby-identifier">lu_col_j</span>[<span class="ruby-identifier">i</span>].<span class="ruby-identifier">abs</span> <span class="ruby-operator">&gt;</span> <span class="ruby-identifier">lu_col_j</span>[<span class="ruby-identifier">p</span>].<span class="ruby-identifier">abs</span>)
        <span class="ruby-identifier">p</span> = <span class="ruby-identifier">i</span>
      <span class="ruby-keyword">end</span>
    <span class="ruby-keyword">end</span>
    <span class="ruby-keyword">if</span> (<span class="ruby-identifier">p</span> <span class="ruby-operator">!=</span> <span class="ruby-identifier">j</span>)
      <span class="ruby-ivar">@column_count</span>.<span class="ruby-identifier">times</span> <span class="ruby-keyword">do</span> <span class="ruby-operator">|</span><span class="ruby-identifier">k</span><span class="ruby-operator">|</span>
        <span class="ruby-identifier">t</span> = <span class="ruby-ivar">@lu</span>[<span class="ruby-identifier">p</span>][<span class="ruby-identifier">k</span>]; <span class="ruby-ivar">@lu</span>[<span class="ruby-identifier">p</span>][<span class="ruby-identifier">k</span>] = <span class="ruby-ivar">@lu</span>[<span class="ruby-identifier">j</span>][<span class="ruby-identifier">k</span>]; <span class="ruby-ivar">@lu</span>[<span class="ruby-identifier">j</span>][<span class="ruby-identifier">k</span>] = <span class="ruby-identifier">t</span>
      <span class="ruby-keyword">end</span>
      <span class="ruby-identifier">k</span> = <span class="ruby-ivar">@pivots</span>[<span class="ruby-identifier">p</span>]; <span class="ruby-ivar">@pivots</span>[<span class="ruby-identifier">p</span>] = <span class="ruby-ivar">@pivots</span>[<span class="ruby-identifier">j</span>]; <span class="ruby-ivar">@pivots</span>[<span class="ruby-identifier">j</span>] = <span class="ruby-identifier">k</span>
      <span class="ruby-ivar">@pivot_sign</span> = <span class="ruby-operator">-</span><span class="ruby-ivar">@pivot_sign</span>
    <span class="ruby-keyword">end</span>

    <span class="ruby-comment"># Compute multipliers.</span>

    <span class="ruby-keyword">if</span> (<span class="ruby-identifier">j</span> <span class="ruby-operator">&lt;</span> <span class="ruby-ivar">@row_count</span> <span class="ruby-operator">&amp;&amp;</span> <span class="ruby-ivar">@lu</span>[<span class="ruby-identifier">j</span>][<span class="ruby-identifier">j</span>] <span class="ruby-operator">!=</span> <span class="ruby-value">0</span>)
      (<span class="ruby-identifier">j</span><span class="ruby-value">+1</span>).<span class="ruby-identifier">upto</span>(<span class="ruby-ivar">@row_count</span><span class="ruby-value">-1</span>) <span class="ruby-keyword">do</span> <span class="ruby-operator">|</span><span class="ruby-identifier">i</span><span class="ruby-operator">|</span>
        <span class="ruby-ivar">@lu</span>[<span class="ruby-identifier">i</span>][<span class="ruby-identifier">j</span>] = <span class="ruby-ivar">@lu</span>[<span class="ruby-identifier">i</span>][<span class="ruby-identifier">j</span>].<span class="ruby-identifier">quo</span>(<span class="ruby-ivar">@lu</span>[<span class="ruby-identifier">j</span>][<span class="ruby-identifier">j</span>])
      <span class="ruby-keyword">end</span>
    <span class="ruby-keyword">end</span>
  <span class="ruby-keyword">end</span>
<span class="ruby-keyword">end</span></pre>
                              </div>
                            </div>


                          </div>

                          </section>

                <section id="public-instance-5Buntitled-5D-method-details" class="method-section">
                <header>
                <h3>Public Instance Methods</h3>
                </header>

                  <div id="method-i-det" class="method-detail ">
                            <div class="method-heading">
                              <span class="method-name">det</span><span
                                class="method-args">()</span>
                              <span class="method-click-advice">click to toggle source</span>
                            </div>

                            <div class="method-description">
                              <p>Returns the determinant of <code>A</code>, calculated efficiently from the factorization.</p>

                              <div class="method-source-code" id="det-source">
            <pre><span class="ruby-comment"># File matrix-0.4.2/lib/matrix/lup_decomposition.rb, line 79</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">det</span>
  <span class="ruby-keyword">if</span> (<span class="ruby-ivar">@row_count</span> <span class="ruby-operator">!=</span> <span class="ruby-ivar">@column_count</span>)
    <span class="ruby-identifier">raise</span> <span class="ruby-constant">Matrix</span><span class="ruby-operator">::</span><span class="ruby-constant">ErrDimensionMismatch</span>
  <span class="ruby-keyword">end</span>
  <span class="ruby-identifier">d</span> = <span class="ruby-ivar">@pivot_sign</span>
  <span class="ruby-ivar">@column_count</span>.<span class="ruby-identifier">times</span> <span class="ruby-keyword">do</span> <span class="ruby-operator">|</span><span class="ruby-identifier">j</span><span class="ruby-operator">|</span>
    <span class="ruby-identifier">d</span> <span class="ruby-operator">*=</span> <span class="ruby-ivar">@lu</span>[<span class="ruby-identifier">j</span>][<span class="ruby-identifier">j</span>]
  <span class="ruby-keyword">end</span>
  <span class="ruby-identifier">d</span>
<span class="ruby-keyword">end</span></pre>
                              </div>
                            </div>

                            <div class="aliases">
                              Also aliased as: <a href="LUPDecomposition.html#method-i-determinant">determinant</a>
                            </div>

                          </div>

                  <div id="method-i-determinant" class="method-detail method-alias">
                            <div class="method-heading">
                              <span class="method-name">determinant</span><span
                                class="method-args">()</span>
                            </div>

                            <div class="method-description">
                              

                            </div>


                            <div class="aliases">
                              Alias for: <a href="LUPDecomposition.html#method-i-det">det</a>
                            </div>
                          </div>

                  <div id="method-i-l" class="method-detail ">
                            <div class="method-heading">
                              <span class="method-name">l</span><span
                                class="method-args">()</span>
                              <span class="method-click-advice">click to toggle source</span>
                            </div>

                            <div class="method-description">
                              

                              <div class="method-source-code" id="l-source">
            <pre><span class="ruby-comment"># File matrix-0.4.2/lib/matrix/lup_decomposition.rb, line 22</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">l</span>
  <span class="ruby-constant">Matrix</span>.<span class="ruby-identifier">build</span>(<span class="ruby-ivar">@row_count</span>, [<span class="ruby-ivar">@column_count</span>, <span class="ruby-ivar">@row_count</span>].<span class="ruby-identifier">min</span>) <span class="ruby-keyword">do</span> <span class="ruby-operator">|</span><span class="ruby-identifier">i</span>, <span class="ruby-identifier">j</span><span class="ruby-operator">|</span>
    <span class="ruby-keyword">if</span> (<span class="ruby-identifier">i</span> <span class="ruby-operator">&gt;</span> <span class="ruby-identifier">j</span>)
      <span class="ruby-ivar">@lu</span>[<span class="ruby-identifier">i</span>][<span class="ruby-identifier">j</span>]
    <span class="ruby-keyword">elsif</span> (<span class="ruby-identifier">i</span> <span class="ruby-operator">==</span> <span class="ruby-identifier">j</span>)
      <span class="ruby-value">1</span>
    <span class="ruby-keyword">else</span>
      <span class="ruby-value">0</span>
    <span class="ruby-keyword">end</span>
  <span class="ruby-keyword">end</span>
<span class="ruby-keyword">end</span></pre>
                              </div>
                            </div>


                          </div>

                  <div id="method-i-p" class="method-detail ">
                            <div class="method-heading">
                              <span class="method-name">p</span><span
                                class="method-args">()</span>
                              <span class="method-click-advice">click to toggle source</span>
                            </div>

                            <div class="method-description">
                              <p>Returns the permutation matrix <code>P</code></p>

                              <div class="method-source-code" id="p-source">
            <pre><span class="ruby-comment"># File matrix-0.4.2/lib/matrix/lup_decomposition.rb, line 48</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">p</span>
  <span class="ruby-identifier">rows</span> = <span class="ruby-constant">Array</span>.<span class="ruby-identifier">new</span>(<span class="ruby-ivar">@row_count</span>){<span class="ruby-constant">Array</span>.<span class="ruby-identifier">new</span>(<span class="ruby-ivar">@row_count</span>, <span class="ruby-value">0</span>)}
  <span class="ruby-ivar">@pivots</span>.<span class="ruby-identifier">each_with_index</span>{<span class="ruby-operator">|</span><span class="ruby-identifier">p</span>, <span class="ruby-identifier">i</span><span class="ruby-operator">|</span> <span class="ruby-identifier">rows</span>[<span class="ruby-identifier">i</span>][<span class="ruby-identifier">p</span>] = <span class="ruby-value">1</span>}
  <span class="ruby-constant">Matrix</span>.<span class="ruby-identifier">send</span> <span class="ruby-value">:new</span>, <span class="ruby-identifier">rows</span>, <span class="ruby-ivar">@row_count</span>
<span class="ruby-keyword">end</span></pre>
                              </div>
                            </div>


                          </div>

                  <div id="method-i-singular-3F" class="method-detail ">
                            <div class="method-heading">
                              <span class="method-name">singular?</span><span
                                class="method-args">()</span>
                              <span class="method-click-advice">click to toggle source</span>
                            </div>

                            <div class="method-description">
                              <p>Returns <code>true</code> if <code>U</code>, and hence <code>A</code>, is singular.</p>

                              <div class="method-source-code" id="singular-3F-source">
            <pre><span class="ruby-comment"># File matrix-0.4.2/lib/matrix/lup_decomposition.rb, line 67</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">singular?</span>
  <span class="ruby-ivar">@column_count</span>.<span class="ruby-identifier">times</span> <span class="ruby-keyword">do</span> <span class="ruby-operator">|</span><span class="ruby-identifier">j</span><span class="ruby-operator">|</span>
    <span class="ruby-keyword">if</span> (<span class="ruby-ivar">@lu</span>[<span class="ruby-identifier">j</span>][<span class="ruby-identifier">j</span>] <span class="ruby-operator">==</span> <span class="ruby-value">0</span>)
      <span class="ruby-keyword">return</span> <span class="ruby-keyword">true</span>
    <span class="ruby-keyword">end</span>
  <span class="ruby-keyword">end</span>
  <span class="ruby-keyword">false</span>
<span class="ruby-keyword">end</span></pre>
                              </div>
                            </div>


                          </div>

                  <div id="method-i-solve" class="method-detail ">
                            <div class="method-heading">
                              <span class="method-name">solve</span><span
                                class="method-args">(b)</span>
                              <span class="method-click-advice">click to toggle source</span>
                            </div>

                            <div class="method-description">
                              <p>Returns <code>m</code> so that <code>A*m = b</code>, or equivalently so that <code>L*U*m = P*b</code> <code>b</code> can be a <a href="../Matrix.html"><code>Matrix</code></a> or a <a href="../Vector.html"><code>Vector</code></a></p>

                              <div class="method-source-code" id="solve-source">
            <pre><span class="ruby-comment"># File matrix-0.4.2/lib/matrix/lup_decomposition.rb, line 95</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">solve</span> <span class="ruby-identifier">b</span>
  <span class="ruby-keyword">if</span> (<span class="ruby-identifier">singular?</span>)
    <span class="ruby-identifier">raise</span> <span class="ruby-constant">Matrix</span><span class="ruby-operator">::</span><span class="ruby-constant">ErrNotRegular</span>, <span class="ruby-string">&quot;Matrix is singular.&quot;</span>
  <span class="ruby-keyword">end</span>
  <span class="ruby-keyword">if</span> <span class="ruby-identifier">b</span>.<span class="ruby-identifier">is_a?</span> <span class="ruby-constant">Matrix</span>
    <span class="ruby-keyword">if</span> (<span class="ruby-identifier">b</span>.<span class="ruby-identifier">row_count</span> <span class="ruby-operator">!=</span> <span class="ruby-ivar">@row_count</span>)
      <span class="ruby-identifier">raise</span> <span class="ruby-constant">Matrix</span><span class="ruby-operator">::</span><span class="ruby-constant">ErrDimensionMismatch</span>
    <span class="ruby-keyword">end</span>

    <span class="ruby-comment"># Copy right hand side with pivoting</span>
    <span class="ruby-identifier">nx</span> = <span class="ruby-identifier">b</span>.<span class="ruby-identifier">column_count</span>
    <span class="ruby-identifier">m</span> = <span class="ruby-ivar">@pivots</span>.<span class="ruby-identifier">map</span>{<span class="ruby-operator">|</span><span class="ruby-identifier">row</span><span class="ruby-operator">|</span> <span class="ruby-identifier">b</span>.<span class="ruby-identifier">row</span>(<span class="ruby-identifier">row</span>).<span class="ruby-identifier">to_a</span>}

    <span class="ruby-comment"># Solve L*Y = P*b</span>
    <span class="ruby-ivar">@column_count</span>.<span class="ruby-identifier">times</span> <span class="ruby-keyword">do</span> <span class="ruby-operator">|</span><span class="ruby-identifier">k</span><span class="ruby-operator">|</span>
      (<span class="ruby-identifier">k</span><span class="ruby-value">+1</span>).<span class="ruby-identifier">upto</span>(<span class="ruby-ivar">@column_count</span><span class="ruby-value">-1</span>) <span class="ruby-keyword">do</span> <span class="ruby-operator">|</span><span class="ruby-identifier">i</span><span class="ruby-operator">|</span>
        <span class="ruby-identifier">nx</span>.<span class="ruby-identifier">times</span> <span class="ruby-keyword">do</span> <span class="ruby-operator">|</span><span class="ruby-identifier">j</span><span class="ruby-operator">|</span>
          <span class="ruby-identifier">m</span>[<span class="ruby-identifier">i</span>][<span class="ruby-identifier">j</span>] <span class="ruby-operator">-=</span> <span class="ruby-identifier">m</span>[<span class="ruby-identifier">k</span>][<span class="ruby-identifier">j</span>]<span class="ruby-operator">*</span><span class="ruby-ivar">@lu</span>[<span class="ruby-identifier">i</span>][<span class="ruby-identifier">k</span>]
        <span class="ruby-keyword">end</span>
      <span class="ruby-keyword">end</span>
    <span class="ruby-keyword">end</span>
    <span class="ruby-comment"># Solve U*m = Y</span>
    (<span class="ruby-ivar">@column_count</span><span class="ruby-value">-1</span>).<span class="ruby-identifier">downto</span>(<span class="ruby-value">0</span>) <span class="ruby-keyword">do</span> <span class="ruby-operator">|</span><span class="ruby-identifier">k</span><span class="ruby-operator">|</span>
      <span class="ruby-identifier">nx</span>.<span class="ruby-identifier">times</span> <span class="ruby-keyword">do</span> <span class="ruby-operator">|</span><span class="ruby-identifier">j</span><span class="ruby-operator">|</span>
        <span class="ruby-identifier">m</span>[<span class="ruby-identifier">k</span>][<span class="ruby-identifier">j</span>] = <span class="ruby-identifier">m</span>[<span class="ruby-identifier">k</span>][<span class="ruby-identifier">j</span>].<span class="ruby-identifier">quo</span>(<span class="ruby-ivar">@lu</span>[<span class="ruby-identifier">k</span>][<span class="ruby-identifier">k</span>])
      <span class="ruby-keyword">end</span>
      <span class="ruby-identifier">k</span>.<span class="ruby-identifier">times</span> <span class="ruby-keyword">do</span> <span class="ruby-operator">|</span><span class="ruby-identifier">i</span><span class="ruby-operator">|</span>
        <span class="ruby-identifier">nx</span>.<span class="ruby-identifier">times</span> <span class="ruby-keyword">do</span> <span class="ruby-operator">|</span><span class="ruby-identifier">j</span><span class="ruby-operator">|</span>
          <span class="ruby-identifier">m</span>[<span class="ruby-identifier">i</span>][<span class="ruby-identifier">j</span>] <span class="ruby-operator">-=</span> <span class="ruby-identifier">m</span>[<span class="ruby-identifier">k</span>][<span class="ruby-identifier">j</span>]<span class="ruby-operator">*</span><span class="ruby-ivar">@lu</span>[<span class="ruby-identifier">i</span>][<span class="ruby-identifier">k</span>]
        <span class="ruby-keyword">end</span>
      <span class="ruby-keyword">end</span>
    <span class="ruby-keyword">end</span>
    <span class="ruby-constant">Matrix</span>.<span class="ruby-identifier">send</span> <span class="ruby-value">:new</span>, <span class="ruby-identifier">m</span>, <span class="ruby-identifier">nx</span>
  <span class="ruby-keyword">else</span> <span class="ruby-comment"># same algorithm, specialized for simpler case of a vector</span>
    <span class="ruby-identifier">b</span> = <span class="ruby-identifier">convert_to_array</span>(<span class="ruby-identifier">b</span>)
    <span class="ruby-keyword">if</span> (<span class="ruby-identifier">b</span>.<span class="ruby-identifier">size</span> <span class="ruby-operator">!=</span> <span class="ruby-ivar">@row_count</span>)
      <span class="ruby-identifier">raise</span> <span class="ruby-constant">Matrix</span><span class="ruby-operator">::</span><span class="ruby-constant">ErrDimensionMismatch</span>
    <span class="ruby-keyword">end</span>

    <span class="ruby-comment"># Copy right hand side with pivoting</span>
    <span class="ruby-identifier">m</span> = <span class="ruby-identifier">b</span>.<span class="ruby-identifier">values_at</span>(<span class="ruby-operator">*</span><span class="ruby-ivar">@pivots</span>)

    <span class="ruby-comment"># Solve L*Y = P*b</span>
    <span class="ruby-ivar">@column_count</span>.<span class="ruby-identifier">times</span> <span class="ruby-keyword">do</span> <span class="ruby-operator">|</span><span class="ruby-identifier">k</span><span class="ruby-operator">|</span>
      (<span class="ruby-identifier">k</span><span class="ruby-value">+1</span>).<span class="ruby-identifier">upto</span>(<span class="ruby-ivar">@column_count</span><span class="ruby-value">-1</span>) <span class="ruby-keyword">do</span> <span class="ruby-operator">|</span><span class="ruby-identifier">i</span><span class="ruby-operator">|</span>
        <span class="ruby-identifier">m</span>[<span class="ruby-identifier">i</span>] <span class="ruby-operator">-=</span> <span class="ruby-identifier">m</span>[<span class="ruby-identifier">k</span>]<span class="ruby-operator">*</span><span class="ruby-ivar">@lu</span>[<span class="ruby-identifier">i</span>][<span class="ruby-identifier">k</span>]
      <span class="ruby-keyword">end</span>
    <span class="ruby-keyword">end</span>
    <span class="ruby-comment"># Solve U*m = Y</span>
    (<span class="ruby-ivar">@column_count</span><span class="ruby-value">-1</span>).<span class="ruby-identifier">downto</span>(<span class="ruby-value">0</span>) <span class="ruby-keyword">do</span> <span class="ruby-operator">|</span><span class="ruby-identifier">k</span><span class="ruby-operator">|</span>
      <span class="ruby-identifier">m</span>[<span class="ruby-identifier">k</span>] = <span class="ruby-identifier">m</span>[<span class="ruby-identifier">k</span>].<span class="ruby-identifier">quo</span>(<span class="ruby-ivar">@lu</span>[<span class="ruby-identifier">k</span>][<span class="ruby-identifier">k</span>])
      <span class="ruby-identifier">k</span>.<span class="ruby-identifier">times</span> <span class="ruby-keyword">do</span> <span class="ruby-operator">|</span><span class="ruby-identifier">i</span><span class="ruby-operator">|</span>
        <span class="ruby-identifier">m</span>[<span class="ruby-identifier">i</span>] <span class="ruby-operator">-=</span> <span class="ruby-identifier">m</span>[<span class="ruby-identifier">k</span>]<span class="ruby-operator">*</span><span class="ruby-ivar">@lu</span>[<span class="ruby-identifier">i</span>][<span class="ruby-identifier">k</span>]
      <span class="ruby-keyword">end</span>
    <span class="ruby-keyword">end</span>
    <span class="ruby-constant">Vector</span>.<span class="ruby-identifier">elements</span>(<span class="ruby-identifier">m</span>, <span class="ruby-keyword">false</span>)
  <span class="ruby-keyword">end</span>
<span class="ruby-keyword">end</span></pre>
                              </div>
                            </div>


                          </div>

                  <div id="method-i-to_a" class="method-detail method-alias">
                            <div class="method-heading">
                              <span class="method-name">to_a</span><span
                                class="method-args">()</span>
                            </div>

                            <div class="method-description">
                              

                            </div>


                            <div class="aliases">
                              Alias for: <a href="LUPDecomposition.html#method-i-to_ary">to_ary</a>
                            </div>
                          </div>

                  <div id="method-i-to_ary" class="method-detail ">
                            <div class="method-heading">
                              <span class="method-name">to_ary</span><span
                                class="method-args">()</span>
                              <span class="method-click-advice">click to toggle source</span>
                            </div>

                            <div class="method-description">
                              <p>Returns <code>L</code>, <code>U</code>, <code>P</code> in an array</p>

                              <div class="method-source-code" id="to_ary-source">
            <pre><span class="ruby-comment"># File matrix-0.4.2/lib/matrix/lup_decomposition.rb, line 56</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">to_ary</span>
  [<span class="ruby-identifier">l</span>, <span class="ruby-identifier">u</span>, <span class="ruby-identifier">p</span>]
<span class="ruby-keyword">end</span></pre>
                              </div>
                            </div>

                            <div class="aliases">
                              Also aliased as: <a href="LUPDecomposition.html#method-i-to_a">to_a</a>
                            </div>

                          </div>

                  <div id="method-i-u" class="method-detail ">
                            <div class="method-heading">
                              <span class="method-name">u</span><span
                                class="method-args">()</span>
                              <span class="method-click-advice">click to toggle source</span>
                            </div>

                            <div class="method-description">
                              <p>Returns the upper triangular factor <code>U</code></p>

                              <div class="method-source-code" id="u-source">
            <pre><span class="ruby-comment"># File matrix-0.4.2/lib/matrix/lup_decomposition.rb, line 36</span>
<span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">u</span>
  <span class="ruby-constant">Matrix</span>.<span class="ruby-identifier">build</span>([<span class="ruby-ivar">@column_count</span>, <span class="ruby-ivar">@row_count</span>].<span class="ruby-identifier">min</span>, <span class="ruby-ivar">@column_count</span>) <span class="ruby-keyword">do</span> <span class="ruby-operator">|</span><span class="ruby-identifier">i</span>, <span class="ruby-identifier">j</span><span class="ruby-operator">|</span>
    <span class="ruby-keyword">if</span> (<span class="ruby-identifier">i</span> <span class="ruby-operator">&lt;=</span> <span class="ruby-identifier">j</span>)
      <span class="ruby-ivar">@lu</span>[<span class="ruby-identifier">i</span>][<span class="ruby-identifier">j</span>]
    <span class="ruby-keyword">else</span>
      <span class="ruby-value">0</span>
    <span class="ruby-keyword">end</span>
  <span class="ruby-keyword">end</span>
<span class="ruby-keyword">end</span></pre>
                              </div>
                            </div>


                          </div>

                          </section>

              </section>
              </main>



            </div>  <!--  class='wrapper hdiv' -->


<footer id="validator-badges" role="contentinfo">
<p><a href="https://validator.w3.org/check/referer">Validate</a></p>
<p>Generated by <a href="https://ruby.github.io/rdoc/">RDoc</a> 6.4.0.</p>
<p>Based on <a href="https://github.com/ged/darkfish/">Darkfish</a> by <a href="http://deveiate.org">Michael Granger</a>.</p>

  
    <p><p><a href="https://ruby-doc.org">Ruby-doc.org</a> is a service of <a href="https://jamesbritt.com">James Britt</a> and <a href="https://neurogami.com">Neurogami</a>, purveyors of fine <a href='https://jamesbritt.bandcamp.com/'>dance noise</a></p>
</p>
  
  </footer>

<script type="text/javascript">


  let ads  = $("#carbonads-container").children().detach();


  function swapMode() {
    var cookieName = 'darkmode';
    var cssDarkmode = Cookies.get(cookieName);
    console.log("***** swapMode! " + cssDarkmode + " *****");


    if (cssDarkmode == "true") {
      console.log("We have dark mode, set the css to light ...");
      $('#rdoccss').attr("href", defaultModeCssHref);
      $('#cssSelect').text("Dark mode");
      cssDarkmode = "false";
      console.log("swapMode! Now set cookie to " + cssDarkmode);
      Cookies.set(cookieName, cssDarkmode);

    } else {
      console.log("We not have dark mode, set the css to dark ...");
      $('#rdoccss').attr("href", darkModeCsseHref);
      $('#cssSelect').text("Light mode");
      cssDarkmode = "true";
      console.log("swapMode! Now set cookie to " + cssDarkmode);
      Cookies.set(cookieName, cssDarkmode);

    }

    console.log("  --------------- ");
  }


const vueCssApp = new Vue({
el: '#menubar',
data: {
isDark: false
},
methods: {
toggleClass: function(event){
this.isDark = !this.isDark;
}
}
})

const vueApp = new Vue({
el: '#vapp',
data: { 
isOpen: true
},

mounted() {
this.handleResize();
this.manage_mob_classes();
window.addEventListener('resize', this.handleResize)
//this.isOpen !=  (/Android|webOS|iPhone|iPad|iPod|BlackBerry|IEMobile|Opera Mini/i.test(navigator.userAgent));
},
destroyed() {
window.removeEventListener('resize', this.handleResize)
},
created() {
//manage_mob_classes();
},

methods : {
isMobile() {
  return (/Android|webOS|iPhone|iPad|iPod|BlackBerry|IEMobile|Opera Mini/i.test(navigator.userAgent));
},

  handleResize() {
    if (!this.isMobile()) {
      this.isOpen = window.innerWidth > 800;
    }
  },

  manage_mob_classes() {
    if (/Android|webOS|iPhone|iPad|iPod|BlackBerry|IEMobile|Opera Mini/i.test(navigator.userAgent)) {
      $("nav").addClass("mob_nav");
      $("main").addClass("mob_main");
      $("#extraz").addClass("mob_extraz");
      $("#carbonads-container").addClass("mob_carbonads-container");
      this.isOpen  = false;
    } else {
      $("nav").removeClass("mob_nav") 
        $("main").removeClass("mob_main");
      $("#extraz").removeClass("mob_extraz");
      $("#carbonads-container").removeClass("mob_carbonads-container");
      this.isOpen  = true;
    }
  },

  toggleNav() {
    this.isOpen =! this.isOpen ;
    // alert("Toggle nav!");
    console.log("toggleNav() click: " + this.isOpen );
  }
}
})

$("#carbonads-container").append(ads);


$(function() {

    var darkmode = Cookies.get("darkmode");
    console.log("Document ready: " + darkmode);

    if ( darkmode  == "true" ) {
      $('#cssSelect').text("Light mode");
    } else {
      $('#cssSelect').text("Dark mode");
     }

    $('body').css('display','block');
    });

</script>

    
  </body> 
</html>

